package edu.codink.common.base;

import java.io.Serializable;
import java.util.List;

import org.hibernate.Query;

/**
 * 
 * @author ylsu
 * 
 */
public class BasicService implements IBasicService
{
	private BasicHbmDao dao;

	public <T extends Serializable> boolean save(T obj)
	{
		this.getDao().save(obj);
		return true;

	}

	public <T extends Serializable> boolean saveOrUpdate(T obj)
	{
		this.getDao().saveOrUpdate(obj);
		return true;
	}

	public <T extends Serializable> boolean update(T obj)
	{
		this.getDao().update(obj);
		return true;
	}

	/**
	 * 删除对象信息
	 * 
	 * @param obj
	 */
	public <T extends Serializable> void remove(T obj)
	{
		this.getDao().remove(obj);
	}

	/**
	 * 根据指定的CLASS及主键ID，删除对象的基本信息
	 * 
	 * @param clazz
	 * @param id
	 */
	public <T extends Serializable> void remove(Class<T> clazz,
			final Serializable id)
	{
		this.getDao().remove(clazz, id);
	}

	/**
	 * 加载单个对象
	 * 
	 * @param <T>
	 * @param clazz
	 * @param id
	 * @return
	 */
	public <T extends Serializable> T find(Class<T> clazz, final Serializable id)
	{
		return this.getDao().find(clazz, id);
	}

	/**
	 * 查询某类对象所有的数据
	 * 
	 * @param <T>
	 * @param clazz
	 * @return
	 */
	public <T extends Serializable> List<T> findAll(Class<T> clazz,
			String orderBy)
	{
		return this.getDao().findAll(clazz, orderBy);
	}

	public <T extends Serializable> boolean saveOrUpdateAll(List<T> list)
	{
		if (list.isEmpty())
			return true;
		this.getDao().saveOrUpdateAll(list);
		return true;
	}

	public boolean updateByHqlQuery(final String queryString,
			final Object[] params)
	{
		this.getDao().updateByHqlQuery(queryString, params);
		return true;
	}

	public void updateByHqlQuery(final String queryStr)
	{
		this.getDao().updateByHqlQuery(queryStr);
	}

	public <T extends Serializable> boolean del(T obj)
	{
		this.getDao().del(obj);
		return true;
	}

	public <T extends Serializable> boolean delAll(List<T> list)
	{
		if (list.isEmpty())
			return true;
		this.getDao().delAll(list);
		return true;
	}

	public <T extends Serializable> void delAll(final Class<T> clazz)
	{
		getDao().delAll(clazz);
	}

	public <T extends Serializable> boolean delById(Class<T> clazz,
			Serializable id)
	{
		this.getDao().delById(clazz, id);
		return true;
	}

	public void delByHqlQuery(String queryString, Object[] parameters)
	{
		this.getDao().delByHqlQuery(queryString, parameters);
	}

	public <T extends Serializable> List<T> findAll(Class<T> clazz)
	{
		return this.getDao().findAll(clazz);
	}

	public <T extends Serializable> T findOneHql(final String hql,
			final Class<T> entityClass)
	{
		return this.getDao().findOne(hql, entityClass);
	}

	public <T extends Serializable> T findOneHql(final String hql,
			Object[] params, final Class<T> entityClass)
	{
		return this.getDao().findOne(hql, params, entityClass);
	}

	public <T extends Serializable> T load(Class<T> clazz, Serializable id)
	{

		return getDao().load(clazz, (Serializable) id);
	}

	public <T extends Serializable> T get(Class<T> clazz, Serializable id)
	{
		return (T) getDao().get(clazz, id);
	}

	public <T> List<T> findByNamedQuery(String queryName)
	{
		return this.getDao().findByNamedQuery(queryName);
	}

	public <T> List<T> findByNamedQuery(String queryName, Object[] params)
	{
		return getDao().find(queryName, params);
	}

	@SuppressWarnings("unchecked")
	public List findHql(String hql)
	{
		return getDao().findHql(hql);
	}

	public <T> List<T> findHql(String hql, Class<T> entityClass)
	{
		return getDao().findHql(hql, entityClass);
	}

	public void flush()
	{
		this.getDao().flush();
	}

	public <T> List<T> findHql(String queryString, final Object[] params)
	{
		return getDao().find(queryString, params);
	}

	public <T extends Serializable> T merge(T t)
	{
		T rtn = this.getDao().merge(t);
		return rtn;
	}

	/**
	 * 通过HQL的方式进行数据查询，并进行分页
	 * 
	 * @param hql
	 *            HQL语句
	 * @param page
	 *            分布对象
	 * @param params
	 *            参数对象
	 * @return
	 */
	public <T> List<T> selectByPageHql(final String hql, final Page page,
			final Object... params)
	{
		return getDao().selectByPageHql(hql, page, params);
	}

	/**
	 * 通过HQL的方式查询数量
	 * 
	 * @param sql
	 * @param params
	 * @return
	 */
	public long hqlCount(String hql, Object... params)
	{
		return (Long) getDao().find(hql, params).get(0);
	}

	/**
	 * 通过HQL的方式更新数据
	 * 
	 * @param hql
	 * @param params
	 * @return
	 */
	public int updateOrDelByHql(final String hql, final Object... params)
	{
		int value = (Integer) getDao().updateOrDelHql(hql, params);
		return value;
	}

	/**
	 * 通过SQL的方式更新数据
	 * 
	 * @param sql
	 * @param params
	 * @return
	 */
	public int updateOrDelBySql(final String sql, final List<Object> params)
	{
		return this.getDao().updateOrDelBySql(sql, params);
	}

	public <T> List<T> findBySQL(final String sql)
	{
		return getDao().findSQL(sql);
	}

	public <T> List<T> findBySQL(final String sql, final Class<T> entityClass)
	{
		return getDao().findSQL(sql);
	}

	/**
	 * 通过HQL的方式进行数据查询
	 * 
	 * @param hql
	 *            HQL语句
	 * @param clazz
	 *            查询结果对应的CLASS
	 * @param params
	 *            参数对象
	 * @return
	 */
	public <T> List<T> selectAllByHql(String hql, Object... params)
	{
		return this.getDao().selectAllHql(hql, params);
	}

	/**
	 * 通过HQL的方式进行数据查询，并进行分页
	 * 
	 * @param hql
	 *            HQL语句
	 * @param clazz
	 *            查询结果对应的CLASS
	 * @param page
	 *            分布对象
	 * @param params
	 *            参数对象
	 * @return
	 */
	public <T> List<T> selectByPageSql(final String sql, final Page page,
			final Object... params)
	{
		return getDao().selectByPageSql(sql, page, params);
	}

	/**
	 * 通过SQL的方式进行数据查询，并进行分页
	 * 
	 * @param sql
	 *            SQL语句
	 * @param clazz
	 *            查询结果对应的CLASS
	 * @param page
	 *            分布对象
	 * @param params
	 *            参数对象
	 * @return
	 */
	public <T> List<T> selectByStartLimitPageSql(final String sql,
			final Page page, final Object... params)
	{
		return getDao().selectByStartLimitPageSql(sql, page, params);
	}

	/**
	 * 通过SQL查询单个对象
	 * 
	 * @param <T>
	 * @param sql
	 * @param params
	 * @return
	 */
	public Object selectObjBySql(String sql, Object... params)
	{
		return this.getDao().selectObjBySql(sql, params);
	}

	/**
	 * 通过SQL的方式进行数据查询
	 * 
	 * @param hql
	 *            HQL语句
	 * @param clazz
	 *            查询结果对应的CLASS
	 * @param params
	 *            参数对象
	 * @return
	 */
	public <T> List<T> selectAllBySql(String sql, Object... params)
	{
		return this.getDao().selectAllSql(sql, params);
	}

	/**
	 * 获得Query
	 * 
	 * @param hql
	 * @return zhangliang 2011-8-1
	 */
	public Query createHqlQuery(String hql)
	{
		return this.getDao().createHqlQuery(hql);
	}

	/**
	 * 通过SQL的方式更新数据
	 * 
	 * @param sql
	 * @param params
	 * @return
	 */
	public int updateOrDelBySql(final String sql, final Object... params)
	{
		return this.getDao().updateOrDelBySql(sql, params);
	}

	private BasicHbmDao getDao()
	{
		if (dao == null)
		{
			dao = (BasicHbmDao) ContextUtil.getBean("basicHbmDao");
		}
		return dao;
	}

	public void setDao(BasicHbmDao dao)
	{
		this.dao = dao;
	}

	/**
	 * 通过HQL的方式进行数据查询，并进行分页
	 * 
	 * @param hql
	 *            HQL语句
	 * @param page
	 *            分布对象,通过limit、start来查询分页
	 * @param params
	 *            参数对象
	 * @return
	 */
	public <T> List<T> selectByStartLimitPageHql(String hql, Page page,
			Object... params)
	{
		return getDao().selectByStartLimitPageHql(hql, page, params);
	}
}